Usenet 1993 July/InfoMagic USENET CD-ROM July 1993.ISO/sources/misc/volume17/cproto/part02

Internet Message Format | 1991-03-25 | 47.8 KB

From: [e-mail] (Chin Huang)
Newsgroups: comp.sources.misc
Subject: v17i071:  cproto - Generate C function prototypes from C source, Part02/02
Message-ID: <[e-mail]>
Date: 25 Mar 91 22:12:01 GMT
Approved: [e-mail]
X-Checksum-Snefru: ce869bec 12106b73 4d93aea9 8fa9d9cb

Submitted-by: Chin Huang <[e-mail]>
Posting-number: Volume 17, Issue 71
Archive-name: cproto/part02

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of shell archive."
# Contents:  lex.l grammar.y config.h cproto.h patchlev.h semantic.h
#   symbol.h cproto.c semantic.c string.c symbol.c
# Wrapped by [e-mail] on Mon Mar 25 11:41:06 1991
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f lex.l -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"lex.l\"
else
echo shar: Extracting \"lex.l\" \(4859 characters\)
sed "s/^X//" >lex.l <<'END_OF_lex.l'
X%{
X/* $Id: lex.l 2.1 91/03/25 11:40:27 cthuang Exp $
X *
X * C function prototype generator
X * Lexical analyzer specification
X */
X%}
X
XWS        [ \t]
XWLF        [ \t\n\f]*
XLETTER        [A-Za-z_]
XDIGIT        [0-9]
XID        {LETTER}({LETTER}|{DIGIT})*
XQUOTED        (\"(\\\"|[^"\n])*\"|\'.\'|\\.)
X
X%{
Xchar cur_file[MAX_TEXT_LENGTH];    /* current file name */
Xint line_num = 1;        /* current line number in file */
Xstatic int curly = 0;        /* number of curly brace nesting levels */
X
Xtypedef struct {
X    FILE *fp;
X    char *file;
X    int line_num;
X} IncludeStack;
X
Xstatic int inc_depth = 0;            /* include nesting level */
Xstatic IncludeStack inc_stack[MAX_INC_DEPTH];    /* stack of included files */
Xstatic void do_include();
X%}
X
X%s CPP1 CPP2 INIT1 INIT2 CURLY COMMENT
X%%
X
X\n            ++line_num;
X
X<INITIAL>^#{WS}*    BEGIN CPP1;
X<CPP1>define{WS}+{ID}.*\\$    {
X                sscanf(yytext, "define %s", buf);
X                new_symbol(typedef_names, buf);
X                BEGIN CPP2;
X            }
X<CPP1>define{WS}+{ID}.*$    {
X                sscanf(yytext, "define %s", buf);
X                new_symbol(typedef_names, buf);
X                BEGIN INITIAL;
X            }
X<CPP2>.*\\$        ;
X<CPP2>.*$        BEGIN INITIAL;
X
X<CPP1>include{WS}+\"[^"]+\".*$    {
X                sscanf(yytext, "include \"%[^\"]\"", buf);
X                do_include(buf, 0);
X                BEGIN INITIAL;
X            }
X<CPP1>include{WS}+\<[^>]+\>.*$    {
X                sscanf(yytext, "include <%[^>]>", buf);
X                do_include(buf, 1);
X                BEGIN INITIAL;
X            }
X
X<CPP1>[0-9]+{WS}+\".*$    {
X                sscanf(yytext, "%d \"%[^\"]\"", &line_num,
X                 cur_file);
X                --line_num;
X                BEGIN INITIAL;
X            }
X<CPP1>[0-9]+.*$        {
X                sscanf(yytext, "%d ", &line_num);
X                --line_num;
X                BEGIN INITIAL;
X            }
X
X<CPP1>.*$        BEGIN INITIAL;
X
X<INITIAL>"("        return '(';
X<INITIAL>")"        return ')';
X<INITIAL>"*"        return '*';
X<INITIAL>","        return ',';
X<INITIAL>";"        return ';';
X<INITIAL>"..."        return T_ELLIPSIS;
X
X<INITIAL>auto        return T_AUTO;
X<INITIAL>extern        return T_EXTERN;
X<INITIAL>register    return T_REGISTER;
X<INITIAL>static        return T_STATIC;
X<INITIAL>typedef    return T_TYPEDEF;
X<INITIAL>char        return T_CHAR;
X<INITIAL>double        return T_DOUBLE;
X<INITIAL>float        return T_FLOAT;
X<INITIAL>int        return T_INT;
X<INITIAL>void        return T_VOID;
X<INITIAL>long        return T_LONG;
X<INITIAL>short        return T_SHORT;
X<INITIAL>signed        return T_SIGNED;
X<INITIAL>unsigned    return T_UNSIGNED;
X<INITIAL>enum        return T_ENUM;
X<INITIAL>struct        return T_STRUCT;
X<INITIAL>union        return T_UNION;
X<INITIAL>const        return T_CONST;
X<INITIAL>volatile    return T_VOLATILE;
X<INITIAL>inline        return T_INLINE;
X<INITIAL>\"C\"        return T_QUOTEC;
X<INITIAL>cdecl        return T_CDECL;
X<INITIAL>far        return T_FAR;
X<INITIAL>huge        return T_HUGE;
X<INITIAL>interrupt    return T_INTERRUPT;
X<INITIAL>near        return T_NEAR;
X<INITIAL>pascal        return T_PASCAL;
X
X<INITIAL>\[[^\]]*\]    {
X                strcpy(yylval.text, yytext);
X                return T_BRACKETS;
X            }
X
X<INITIAL>{ID}        {
X                strcpy(yylval.text, yytext);
X                if (is_typedef_name(yytext))
X                return T_TYPEDEF_NAME;
X                else
X                return T_IDENTIFIER;
X            }
X
X<INITIAL>"="{WLF}"{"    {
X                int i;
X
X                curly = 1;
X                BEGIN INIT1;
X                for (i = 0; i < yyleng; ++i)
X                if (yytext[i] == '\n') ++line_num;
X            }
X<INIT1>"{"        ++curly;
X<INIT1>"}"        {
X                if (--curly == 0) {
X                BEGIN INITIAL;
X                return T_INITIALIZER;
X                }
X            }
X<INIT1>{QUOTED}|.    ;
X
X<INITIAL>"="        BEGIN INIT2;
X<INIT2>[,;]        {
X                unput(yytext[yyleng-1]);
X                BEGIN INITIAL;
X                return T_INITIALIZER;
X            }
X<INIT2>{QUOTED}|.    ;
X
X<INITIAL>"{"        { curly = 1; BEGIN CURLY; }
X<CURLY>"{"        ++curly;
X<CURLY>"}"        {
X                if (--curly == 0) {
X                BEGIN INITIAL;
X                return T_BRACES;
X                }
X            }
X<CURLY>{QUOTED}|.    ;
X
X<INITIAL>"/*"        BEGIN COMMENT;
X<COMMENT>"*/"        BEGIN INITIAL;
X<COMMENT>.        ;
X
X<INITIAL>"//".*$    ;
X
X[ \t\f]+        ;
X.            {
X                output_error();
X                fprintf(stderr, "bad character '%c'\n", yytext[0]);
X            }
X%%
X
X/* Process include directive.
X */
Xstatic void
Xdo_include (filename, sysinc)
Xchar *filename;        /* file name */
Xint sysinc;        /* 1 = do not search current directory */
X{
X    char path[MAX_TEXT_LENGTH];
X    int i;
X    FILE *fp;
X    IncludeStack *sp;
X
X    if (inc_depth >= MAX_INC_DEPTH) {
X    output_error();
X    fprintf(stderr, "includes too deeply nested\n");
X    return;
X    }
X
X    for (i = sysinc != 0; i < num_inc_dir; ++i) {
X     strcpy(path, inc_dir[i]);
X     strcat(path, filename);
X     if ((fp = fopen(path, "r")) != NULL) {
X         sp = inc_stack + inc_depth;
X         sp->fp = yyin;
X         sp->file = strdup(cur_file);
X         sp->line_num = line_num;
X         ++inc_depth;
X         yyin = fp;
X         strcpy(cur_file, filename);
X         line_num = 0;
X         return;
X     }
X    }
X}
X
X/* When the end of the current input file is reached, pop any
X * nested includes.
X */
Xstatic int
Xyywrap ()
X{
X    IncludeStack *sp;
X
X    if (inc_depth > 0) {
X    --inc_depth;
X    sp = inc_stack + inc_depth;
X    fclose(yyin);
X    yyin = sp->fp;
X    strcpy(cur_file, sp->file);
X    free(sp->file);
X    line_num = sp->line_num + 1;
X    return 0;
X    } else {
X    return 1;
X    }
X}
END_OF_lex.l
if test 4859 -ne `wc -c <lex.l`; then
    echo shar: \"lex.l\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f grammar.y -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"grammar.y\"
else
echo shar: Extracting \"grammar.y\" \(10073 characters\)
sed "s/^X//" >grammar.y <<'END_OF_grammar.y'
X/* $Id: grammar.y 2.1 91/02/28 11:16:07 cthuang Exp $
X *
X * yacc grammar for C prototype generator
X * This was derived from the grammar given in Appendix A of
X * "The C Programming Language" by Kernighan and Ritchie.
X */
X
X/* identifiers that are not reserved words */
X%token T_IDENTIFIER T_TYPEDEF_NAME
X
X/* storage class */
X%token T_AUTO T_EXTERN T_REGISTER T_STATIC T_TYPEDEF
X/* This keyword included for compatibility with C++. */
X%token T_INLINE
X
X/* type specifiers */
X%token T_CHAR T_DOUBLE T_FLOAT T_INT T_VOID
X%token T_LONG T_SHORT T_SIGNED T_UNSIGNED
X%token T_ENUM T_STRUCT T_UNION
X
X/* type qualifiers */
X%token T_CONST T_VOLATILE
X/* These keywords included for compatibility with MSDOS C compilers. */
X%token T_CDECL T_FAR T_HUGE T_INTERRUPT T_NEAR T_PASCAL
X
X/* paired braces and everything between them: { ... } */
X%token T_BRACES
X
X/* paired square brackets and everything between them: [ ... ] */
X%token T_BRACKETS
X
X/* three periods */
X%token T_ELLIPSIS
X
X/* equal sign followed by constant expression or stuff between braces */
X%token T_INITIALIZER
X
X/* "C" */
X%token T_QUOTEC
X
X%type <decl_spec> declaration_specifiers declaration_specifier
X%type <decl_spec> storage_class type_specifier type_qualifier
X%type <decl_spec> struct_or_union_specifier enum_specifier
X%type <decl_list> init_declarator_list
X%type <declarator> init_declarator declarator direct_declarator
X%type <declarator> abs_declarator direct_abs_declarator
X%type <param_list> parameter_type_list parameter_list
X%type <parameter> parameter_declaration
X%type <param_list> opt_identifier_list identifier_list
X%type <text> struct_or_union
X%type <text> pointer type_qualifiers
X%type <text> any_id T_IDENTIFIER T_TYPEDEF_NAME
X%type <text> T_BRACKETS
X
X%{
X#include <stdio.h>
X#include "cproto.h"
X#include "semantic.h"
X
X#define YYMAXDEPTH 150
X
X/* This variable is set TRUE when we are scanning the parameter declarations
X * part of a function definition.
X */
Xstatic boolean func_params = FALSE;
X
X/* This points to the list of parameters for the current function definition. */
Xstatic ParameterList *cur_params;
X
X/* temporary string buffer */
Xstatic char buf[MAX_TEXT_LENGTH];
X
X/* Table of typedef names */
XSymbolTable *typedef_names;
X%}
X%%
X
Xprogram
X    : /* empty */
X    | translation_unit
X    ;
X
Xtranslation_unit
X    : external_declaration
X    | translation_unit external_declaration
X    ;
X
Xexternal_declaration
X    : declaration
X    | function_definition
X    | T_EXTERN T_QUOTEC T_BRACES
X    | error
X    ;
X
Xdeclaration
X    : declaration_specifiers ';'
X    {
X        free_decl_spec(&$1);
X    }
X    | declaration_specifiers init_declarator_list ';'
X    {
X        if (func_params) {
X        set_param_types(cur_params, &$1, &$2);
X        } else {
X        output_declarations(&$1, &$2);
X        }
X        free_decl_spec(&$1);
X        free_decl_list(&$2);
X    }
X    | T_TYPEDEF declaration_specifiers declarator_list ';'
X    {
X        free_decl_spec(&$2);
X    }
X    ;
X
Xdeclarator_list
X    : declarator
X    {
X        new_symbol(typedef_names, $1.name);
X        free_declarator(&$1);
X    }
X    | declarator_list ',' declarator
X    {
X        new_symbol(typedef_names, $3.name);
X        free_declarator(&$3);
X    }
X    ;
X
Xfunction_definition
X    : declaration_specifiers declarator
X    {
X        if ($2.func_def == FUNC_NONE) {
X        yyerror("syntax error");
X        YYERROR;
X        }
X        cur_params = &($2.params);
X        func_params = TRUE;
X    }
X      opt_declaration_list T_BRACES
X    {
X        func_params = FALSE;
X
X        output_prototype(&$1, &$2);
X        free_decl_spec(&$1);
X        free_declarator(&$2);
X    }
X    | declarator
X    {
X        if ($1.func_def == FUNC_NONE) {
X        yyerror("syntax error");
X        YYERROR;
X        }
X        cur_params = &($1.params);
X        func_params = TRUE;
X    }
X      opt_declaration_list T_BRACES
X    {
X        DeclSpec    decl_spec;
X
X        func_params = FALSE;
X
X        new_decl_spec(&decl_spec, "int", DE_EXTERN);
X        output_prototype(&decl_spec, &$1);
X        free_decl_spec(&decl_spec);
X        free_declarator(&$1);
X    }
X    ;
X
Xopt_declaration_list
X    : /* empty */
X    | declaration_list
X    ;
X
Xdeclaration_list
X    : declaration
X    | declaration_list declaration
X    ;
X
Xdeclaration_specifiers
X    : declaration_specifier
X    | declaration_specifiers declaration_specifier
X    {
X        join_decl_specs(&$$, &$1, &$2);
X    }
X    ;
X
Xdeclaration_specifier
X    : storage_class
X    | type_specifier
X    | type_qualifier
X    ;
X
Xstorage_class
X    : T_AUTO
X    {
X        new_decl_spec(&$$, "auto", DE_JUNK);
X    }
X    | T_EXTERN
X    {
X        new_decl_spec(&$$, "extern", DE_JUNK);
X    }
X    | T_REGISTER
X    {
X        new_decl_spec(&$$, "register", DE_JUNK);
X    }
X    | T_STATIC
X    {
X        new_decl_spec(&$$, "static", DE_STATIC);
X    }
X    | T_INLINE
X    {
X        new_decl_spec(&$$, "inline", DE_JUNK);
X    }
X    ;
X
Xtype_specifier
X    : T_CHAR
X    {
X        new_decl_spec(&$$, "char", DE_EXTERN);
X    }
X    | T_DOUBLE
X    {
X        new_decl_spec(&$$, "double", DE_EXTERN);
X    }
X    | T_FLOAT
X    {
X        new_decl_spec(&$$, "float", DE_EXTERN);
X    }
X    | T_INT
X    {
X        new_decl_spec(&$$, "int", DE_EXTERN);
X    }
X    | T_LONG
X    {
X        new_decl_spec(&$$, "long", DE_EXTERN);
X    }
X    | T_SHORT
X    {
X        new_decl_spec(&$$, "short", DE_EXTERN);
X    }
X    | T_SIGNED
X    {
X        new_decl_spec(&$$, "signed", DE_EXTERN);
X    }
X    | T_UNSIGNED
X    {
X        new_decl_spec(&$$, "unsigned", DE_EXTERN);
X    }
X    | T_VOID
X    {
X        new_decl_spec(&$$, "void", DE_EXTERN);
X    }
X    | struct_or_union_specifier
X    | enum_specifier
X    | T_TYPEDEF_NAME
X    {
X        new_decl_spec(&$$, $1, DE_EXTERN);
X    }
X    ;
X
Xtype_qualifier
X    : T_CONST
X    {
X        new_decl_spec(&$$, "const", DE_EXTERN);
X    }
X    | T_VOLATILE
X    {
X        new_decl_spec(&$$, "volatile", DE_EXTERN);
X    }
X    | T_CDECL
X    {
X        new_decl_spec(&$$, "cdecl", DE_EXTERN);
X    }
X    | T_INTERRUPT
X    {
X        new_decl_spec(&$$, "interrupt", DE_EXTERN);
X    }
X    | T_FAR
X    {
X        new_decl_spec(&$$, "far", DE_EXTERN);
X    }
X    | T_HUGE
X    {
X        new_decl_spec(&$$, "huge", DE_EXTERN);
X    }
X    | T_NEAR
X    {
X        new_decl_spec(&$$, "near", DE_EXTERN);
X    }
X    | T_PASCAL
X    {
X        new_decl_spec(&$$, "pascal", DE_EXTERN);
X    }
X    ;
X
Xstruct_or_union_specifier
X    : struct_or_union any_id T_BRACES
X    {
X        sprintf(buf, "%s %s {}", $1, $2);
X        new_decl_spec(&$$, buf, DE_EXTERN);
X    }
X    | struct_or_union T_BRACES
X    {
X        sprintf(buf, "%s {}", $1);
X        new_decl_spec(&$$, buf, DE_EXTERN);
X    }
X    | struct_or_union any_id
X    {
X        sprintf(buf, "%s %s", $1, $2);
X        new_decl_spec(&$$, buf, DE_EXTERN);
X    }
X    ;
X
Xstruct_or_union
X    : T_STRUCT
X    {
X        strcpy($$, "struct");
X    }
X    | T_UNION
X    {
X        strcpy($$, "union");
X    }
X    ;
X
Xinit_declarator_list
X    : init_declarator
X    {
X        new_decl_list(&$$, &$1);
X    }
X    | init_declarator_list ',' init_declarator
X    {
X        add_decl_list(&$$, &$1, &$3);
X    }
X    ;
X
Xinit_declarator
X    : declarator
X    | declarator T_INITIALIZER
X    ;
X
Xenum_specifier
X    : T_ENUM any_id T_BRACES
X    {
X        sprintf(buf, "enum %s {}", $2);
X        new_decl_spec(&$$, buf, DE_EXTERN);
X    }
X    | T_ENUM T_BRACES
X    {
X        new_decl_spec(&$$, "enum {}", DE_EXTERN);
X    }
X    | T_ENUM any_id
X    {
X        sprintf(buf, "enum %s", $2);
X        new_decl_spec(&$$, buf, DE_EXTERN);
X    }
X    ;
X
Xany_id
X    : T_IDENTIFIER
X    | T_TYPEDEF_NAME
X    ;
X
Xdeclarator
X    : pointer direct_declarator
X    {
X        sprintf(buf, "%s%s", $1, $2.text);
X        $$ = $2;
X        $$.text = strdup(buf);
X        free($2.text);
X    }
X    | direct_declarator
X    ;
X
Xdirect_declarator
X    : T_IDENTIFIER
X    {
X        new_declarator(&$$, $1, $1);
X    }
X    | '(' declarator ')'
X    {
X        sprintf(buf, "(%s)", $2.text);
X        $$ = $2;
X        $$.text = strdup(buf);
X        free($2.text);
X    }
X    | direct_declarator T_BRACKETS
X    {
X        sprintf(buf, "%s%s", $1.text, $2);
X        $$ = $1;
X        $$.text = strdup(buf);
X        free($1.text);
X    }
X    | direct_declarator '(' parameter_type_list ')'
X    {
X        sprintf(buf, "%s()", $1.text);
X        $$ = $1;
X        $$.text = strdup(buf);
X        $$.func_def = FUNC_ANSI;
X        $$.params = $3;
X        free($1.text);
X    }
X    | direct_declarator '(' opt_identifier_list ')'
X    {
X        sprintf(buf, "%s()", $1.text);
X        $$ = $1;
X        $$.text = strdup(buf);
X        $$.func_def = FUNC_TRADITIONAL;
X        if ($3.first != NULL) {
X        $$.params = $3;
X        }
X        free($1.text);
X    }
X    ;
X
Xpointer
X    : '*' type_qualifiers
X    {
X        sprintf($$, "*%s", $2);
X    }
X    | '*' type_qualifiers pointer
X    {
X        sprintf($$, "*%s%s", $2, $3);
X    }
X    ;
X
Xtype_qualifiers
X    : /* empty */
X    {
X        strcpy($$, "");
X    }
X    | type_qualifiers type_qualifier
X    {
X        sprintf($$, "%s %s ", $1, $2.text);
X        free($2.text);
X    }
X    ;
X
Xparameter_type_list
X    : parameter_list
X    | parameter_list ',' T_ELLIPSIS
X    {
X        add_ident_list(&$$, &$1, "...");
X    }
X    ;
X
Xparameter_list
X    : parameter_declaration
X    {
X        new_param_list(&$$, &$1);
X    }
X    | parameter_list ',' parameter_declaration
X    {
X        add_param_list(&$$, &$1, &$3);
X    }
X    ;
X
Xparameter_declaration
X    : declaration_specifiers declarator
X    {
X        new_parameter(&$$, &$1, &$2);
X    }
X    | declaration_specifiers abs_declarator
X    {
X        new_parameter(&$$, &$1, &$2);
X    }
X    | declaration_specifiers
X    {
X        new_parameter(&$$, &$1, NULL);
X    }
X    ;
X
Xopt_identifier_list
X    : /* empty */
X    {
X        new_ident_list(&$$);
X    }
X    | identifier_list
X    ;
X
Xidentifier_list
X    : T_IDENTIFIER
X    {
X        new_ident_list(&$$);
X        add_ident_list(&$$, &$$, $1);
X    }
X    | identifier_list ',' T_IDENTIFIER
X    {
X        add_ident_list(&$$, &$1, $3);
X    }
X    ;
X
Xabs_declarator
X    : pointer
X    {
X        new_declarator(&$$, $1, "");
X    }
X    | pointer direct_abs_declarator
X    {
X        sprintf(buf, "%s%s", $1, $2.text);
X        $$ = $2;
X        $$.text = strdup(buf);
X        free($2.text);
X    }
X    | direct_abs_declarator
X    ;
X
Xdirect_abs_declarator
X    : '(' abs_declarator ')'
X    {
X        sprintf(buf, "(%s)", $2.text);
X        $$ = $2;
X        $$.text = strdup(buf);
X        free($2.text);
X    }
X    | direct_abs_declarator T_BRACKETS
X    {
X        sprintf(buf, "%s%s", $1.text, $2);
X        $$ = $1;
X        $$.text = strdup(buf);
X        free($1.text);
X    }
X    | T_BRACKETS
X    {
X        new_declarator(&$$, $1, "");
X    }
X    | direct_abs_declarator '(' parameter_type_list ')'
X    {
X        sprintf(buf, "%s(%%s)", $1.text);
X        $$ = $1;
X        $$.text = strdup(buf);
X        free($1.text);
X    }
X    | direct_abs_declarator '(' ')'
X    {
X        sprintf(buf, "%s()", $1.text);
X        $$ = $1;
X        $$.text = strdup(buf);
X        free($1.text);
X    }
X    | '(' parameter_type_list ')'
X    {
X        new_declarator(&$$, "()", "");
X    }
X    | '(' ')'
X    {
X        new_declarator(&$$, "()", "");
X    }
X    ;
X
X%%
X#ifdef MSDOS
X#include "lex_yy.c"
X#else
X#include "lex.yy.c"
X#endif
X
Xyyerror (msg)
Xchar *msg;
X{
X    output_error();
X    fprintf(stderr, "%s\n", msg);
X}
X
Xvoid
Xparse_file ()
X{
X    typedef_names = create_symbol_table();
X    yyparse();
X}
END_OF_grammar.y
if test 10073 -ne `wc -c <grammar.y`; then
    echo shar: \"grammar.y\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f config.h -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"config.h\"
else
echo shar: Extracting \"config.h\" \(640 characters\)
sed "s/^X//" >config.h <<'END_OF_config.h'
X/* $Id: config.h 2.1 91/02/28 11:16:12 cthuang Exp $
X *
X * cproto configuration and system dependencies
X */
X
X/* maximum include file nesting */
X#define MAX_INC_DEPTH 15
X
X/* maximum number of include directories */
X#define MAX_INC_DIR 15
X
X/* maximum number of characters in a text buffer */
X#define MAX_TEXT_LENGTH    256
X
X#ifdef __TURBOC__
X#include <alloc.h>
X#endif
X
X#ifdef M_I86
X#include <malloc.h>
X#endif
X
X#ifndef MSDOS
Xextern char *malloc();
X#endif
X
X#if defined(SYSV) || defined(MSDOS)
X#include <string.h>
X#define index strchr
X#define rindex strrchr
X#else
X#include <strings.h>
X#endif
X
X#ifndef MSDOS
Xextern char *strdup(), *strstr();
X#endif
END_OF_config.h
if test 640 -ne `wc -c <config.h`; then
    echo shar: \"config.h\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f cproto.h -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"cproto.h\"
else
echo shar: Extracting \"cproto.h\" \(2851 characters\)
sed "s/^X//" >cproto.h <<'END_OF_cproto.h'
X/* $Id: cproto.h 2.1 91/02/28 11:16:14 cthuang Exp $
X *
X * Definitions for C language prototype generator
X */
X#include "config.h"
X#include "symbol.h"
X
X/* Boolean type */
Xtypedef char boolean;
X#define FALSE    0
X#define TRUE    1
X
X/* This is a list of function parameters. */
Xtypedef struct _parameter_list {
X    struct _parameter    *first;    /* pointer to first parameter in list */
X    struct _parameter    *last;  /* pointer to last parameter in list */
X} ParameterList;
X
X/* Declaration specifier flags */
X#define DE_EXTERN    0    /* default: external declaration */
X#define DE_STATIC    1    /* visible only in current file */
X#define DE_JUNK        2    /* we're not interested in this declaration */
X
X/* This structure stores information about a declaration specifier. */
Xtypedef struct _decl_spec {
X    unsigned short    flags;    /* flags defined above */
X    char        *text;    /* source text */
X} DeclSpec;
X
X/* Styles of function definitions */
Xtypedef enum {
X    FUNC_NONE,        /* not a function definition */
X    FUNC_TRADITIONAL,    /* traditional style */
X    FUNC_ANSI        /* ANSI style */
X} FuncDefType;
X
X/* This structure stores information about a declarator. */
Xtypedef struct _declarator {
X    char        *name;        /* name of variable or function */
X    char        *text;        /* source text */
X    FuncDefType        func_def;    /* style of function definition */
X    ParameterList    params;        /* function parameters */
X    struct _declarator    *next;        /* next declarator in list */
X} Declarator;
X
X/* This is a list of declarators. */
Xtypedef struct _declarator_list {
X    Declarator        *first;    /* pointer to first declarator in list */
X    Declarator        *last;  /* pointer to last declarator in list */
X} DeclaratorList;
X
X/* This structure stores information about a function parameter. */
Xtypedef struct _parameter {
X    DeclSpec        decl_spec;
X    Declarator        declarator;
X    struct _parameter    *next;        /* next parameter in list */
X} Parameter;
X
X/* parser stack entry type */
Xtypedef union {
X    char        text[MAX_TEXT_LENGTH];
X    DeclSpec        decl_spec;
X    Parameter        parameter;
X    ParameterList    param_list;
X    Declarator        declarator;
X    DeclaratorList    decl_list;
X} yystype;
X
X#define YYSTYPE yystype
X
X/* Prototype styles */
X#define PROTO_NONE        0
X#define PROTO_TRADITIONAL    1
X#define PROTO_ABSTRACT        2
X#define PROTO_ANSI        3
X#define PROTO_MACRO        4
X
X/* Program options */
Xextern boolean extern_out;
Xextern boolean static_out;
Xextern boolean variables_out;
Xextern boolean promote_param;
Xextern int proto_style;
Xextern boolean define_macro;
Xextern char *macro_name;
Xextern char *decl_spec_prefix, *declarator_prefix, *declarator_suffix;
Xextern char *first_param_prefix, *middle_param_prefix, *last_param_suffix;
Xextern int num_inc_dir;
Xextern char *inc_dir[];
X
X/* Global declarations */
Xextern int line_num;
Xextern char cur_file[];
Xextern SymbolTable *typedef_names;
Xextern void output_error();
Xextern void parse_file();
END_OF_cproto.h
if test 2851 -ne `wc -c <cproto.h`; then
    echo shar: \"cproto.h\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f patchlev.h -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"patchlev.h\"
else
echo shar: Extracting \"patchlev.h\" \(21 characters\)
sed "s/^X//" >patchlev.h <<'END_OF_patchlev.h'
X#define PATCHLEVEL 0
END_OF_patchlev.h
if test 21 -ne `wc -c <patchlev.h`; then
    echo shar: \"patchlev.h\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f semantic.h -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"semantic.h\"
else
echo shar: Extracting \"semantic.h\" \(1610 characters\)
sed "s/^X//" >semantic.h <<'END_OF_semantic.h'
X/* $Id: semantic.h 2.1 91/02/28 11:16:19 cthuang Exp $
X *
X * Declarations for semantics action routines
X */
X
Xextern boolean is_typedef_name(/*
X    char *name
X    */);
Xextern void new_decl_spec(/*
X    DeclSpec *decl_spec,
X    char *text,
X    unsigned short flags
X    */);
Xextern void join_decl_specs(/*
X    DeclSpec *result,
X    DeclSpec *a,
X    DeclSpec *b
X    */);
Xextern void free_decl_spec(/*
X    DeclSpec *decl_spec
X    */);
Xextern void new_parameter(/*
X    Parameter *param,
X    DeclSpec *decl_spec,
X    Declarator *declarator
X    */);
Xextern void free_parameter(/*
X    Parameter *param
X    */);
Xextern void new_param_list(/*
X    ParameterList *param_list,
X    Parameter *param
X    */);
Xextern void add_param_list(/*
X    ParameterList *to,
X    ParameterList *from,
X    Parameter *param
X    */);
Xextern void free_param_list(/*
X    ParameterList *param_list
X    */);
Xextern void new_ident_list(/*
X    ParameterList *param_list
X    */);
Xextern void add_ident_list(/*
X    ParameterList *to,
X    ParameterList *from,
X    char *name
X    */);
Xextern void new_declarator(/*
X    Declarator *d,
X    char *name,
X    char *text
X    */);
Xextern void free_declarator(/*
X    Declarator *d
X    */);
Xextern void new_decl_list(/*
X    DeclaratorList *decl_list,
X    Declarator *declarator
X    */);
Xextern void add_decl_list(/*
X    DeclaratorList *to,
X    DeclaratorList *from,
X    Declarator *declarator
X    */);
Xextern void free_decl_list(/*
X    DeclaratorList *decl_list
X    */);
Xextern void set_param_types(/*
X    ParameterList *params,
X    DeclSpec *decl_spec,
X    DeclaratorList *declarators
X    */);
Xextern void output_declarations(/*
X    DeclSpec *decl_spec,
X    DeclaratorList *decl_list
X    */);
Xextern void output_prototype(/*
X    DeclSpec *decl_spec,
X    Declarator *declarator
X    */);
END_OF_semantic.h
if test 1610 -ne `wc -c <semantic.h`; then
    echo shar: \"semantic.h\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f symbol.h -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"symbol.h\"
else
echo shar: Extracting \"symbol.h\" \(587 characters\)
sed "s/^X//" >symbol.h <<'END_OF_symbol.h'
X/* $Id: symbol.h 2.1 91/02/28 11:16:22 cthuang Exp $
X *
X * Definitions for a symbol table
X */
X#ifndef _SYMBOL_H
X#define _SYMBOL_H
X
Xtypedef struct _symbol {
X    struct _symbol *next;    /* next symbol in list */
X    char *name;        /* name of symbol */
X} Symbol;
X
X/* hash table length */
X#define SYM_MAX_HASH 256
X
Xtypedef struct _symbol_table {
X    Symbol *bucket[SYM_MAX_HASH];    /* hash buckets */
X} SymbolTable;
X
Xextern SymbolTable *create_symbol_table();    /* Create symbol table */
Xextern Symbol *find_symbol();            /* Lookup symbol name */
Xextern Symbol *new_symbol();            /* Define new symbol */
X
X#endif
END_OF_symbol.h
if test 587 -ne `wc -c <symbol.h`; then
    echo shar: \"symbol.h\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f cproto.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"cproto.c\"
else
echo shar: Extracting \"cproto.c\" \(7676 characters\)
sed "s/^X//" >cproto.c <<'END_OF_cproto.c'
X/* $Id: cproto.c 2.1 91/03/25 11:40:34 cthuang Exp $
X *
X * C prototype generator
X * Reads C source code and outputs ANSI C function prototypes.
X */
X#ifndef lint
Xstatic char *rcsid = "$Id: cproto.c 2.1 91/03/25 11:40:34 cthuang Exp $";
X#endif
X#include <stdio.h>
X#include <ctype.h>
X#include "cproto.h"
X#include "patchlev.h"
X
X/* C preprocessor */
X#ifndef CPP
X#define CPP "/lib/cpp"
X#endif
X
X/* getopt declarations */
Xextern int getopt();
Xextern char *optarg;
Xextern int optind;
X
X/* lex declarations */
Xextern FILE *yyin;    /* lex input stream */
X
X/* Name of the program */
Xstatic char *progname = "cproto";
X
X/* Program options */
X
X/* TRUE if "extern" should appear on external declarations. */
Xboolean extern_out = FALSE;
X
X/* TRUE if static declarations are also output. */
Xboolean static_out = FALSE;
X
X/* TRUE if variable declarations are output. */
Xboolean variables_out = FALSE;
X
X/* TRUE if formal parameter promotion is enabled. */
Xboolean promote_param = TRUE;
X
X/* Style of function prototype generated */
Xint proto_style = PROTO_ANSI;
X
X/* Name of macro to guard prototypes */
Xchar *macro_name = "P_";
X
X/* TRUE if prototype macro definition is output. */
Xboolean define_macro = TRUE;
X
X/* String output before prototype declaration specifiers */
Xchar *decl_spec_prefix = "";
X
X/* String output before prototype declarator */
Xchar *declarator_prefix = " ";
X
X/* String output after prototype declarator */
Xchar *declarator_suffix = "";
X
X/* String output before the first parameter in a function prototype */
Xchar *first_param_prefix = "";
X
X/* String output before each subsequent parameter in a function prototype */
Xchar *middle_param_prefix = " ";
X
X/* String output after the last parameter in a function prototype */
Xchar *last_param_suffix = "";
X
X/* Include file directories */
X#ifdef MSDOS
Xint num_inc_dir = 1;
Xchar *inc_dir[MAX_INC_DIR] = { ".\\" };
X#else
Xint num_inc_dir = 2;
Xchar *inc_dir[MAX_INC_DIR] = { "./", "/usr/include/" };
X#endif
X
X/* Output an error message along with the current line number in the
X * source file.
X */
Xvoid
Xoutput_error ()
X{
X    fprintf(stderr, "\"%s\", line %d: ", cur_file, line_num);
X}
X
X/* Replace any character escape sequences in a string with the actual
X * characters.  Return a pointer to malloc'ed memory containing the result.
X * This function knows only a few escape sequences.
X */
Xstatic char *
Xescape_string (src)
Xchar *src;
X{
X    char *result, *get, *put;
X
X    result = strdup(src);
X    put = result;
X    get = src;
X    while (*get != '\0') {
X    if (*get == '\\') {
X        switch (*(++get)) {
X        case 'n':
X        *put++ = '\n';
X        ++get;
X        break;
X        case 't':
X        *put++ = '\t';
X        ++get;
X        break;
X        default:
X        if (*get != '\0')
X            *put++ = *get++;
X        }
X    } else {
X        *put++ = *get++;
X    }
X    }
X    *put = *get;
X    return result;
X}
X
X/* Append a path name separator to the end of the string if it doesn't
X * end with one already.  Allocate storage for the result and return
X * a pointer to it.
X */
Xstatic char *
Xadd_path_sep (s)
Xchar *s;
X{
X    char *result, ch;
X    int n;
X
X    n = strlen(s);
X    result = malloc(n+2);
X    strcpy(result, s);
X    ch = result[n-1];
X    if (ch != '/' && ch != '\\') {
X    result[n] = '/';
X    result[n+1] = '\0';
X    }
X    return result;
X}
X
X/* Output usage message and exit.
X */
Xstatic void
Xusage ()
X{
X    fprintf(stderr,
X    "usage: %s [ option ... ] [ file ... ]\n", progname);
X    fputs("  -e      output \"extern\" keyword before global declarations\n",
X    stderr);
X    fputs("  -f n    select function prototype style (0 to 4)\n", stderr);
X    fputs("  -p      disable prototype promotion\n", stderr);
X    fputs("  -s      output static declarations\n", stderr);
X    fputs("  -v      output variable declarations\n", stderr);
X    fputs("  -m nam  set name of macro guarding prototypes\n", stderr);
X    fputs("  -d      omit prototype macro definition\n", stderr);
X    fputs("  -D name[=value]\n", stderr);
X    fputs("  -U name\n", stderr);
X    fputs("  -I directory\n", stderr);
X    fputs("          C preprocessor options\n", stderr);
X    fputs(
X    "  -F fmt  set prototype template in the form \"int main (a, b)\"\n",
X    stderr);
X    fputs("  -V      print version information\n", stderr);
X    exit(1);
X}
X
Xmain (argc, argv)
Xint argc;
Xchar **argv;
X{
X    int i, c, n;
X    char *s, *cpp_cmd, tmp[MAX_TEXT_LENGTH];
X#ifndef MSDOS
X    char *cmd;
X#endif
X
X    /* Allocate buffer for C preprocessor command line. */
X    n = strlen(CPP) + 1;
X    for (i = 0; i < argc; ++i) {
X    n += strlen(argv[i]) + 1;
X    }
X    cpp_cmd = malloc(n);
X    strcpy(cpp_cmd, CPP);
X#ifndef MSDOS
X    cmd = malloc(n);
X#endif
X
X    /* Scan command line options. */
X    while ((c = getopt(argc, argv, "D:deF:f:I:m:psU:Vv")) != EOF) {
X    switch (c) {
X    case 'I':
X        if (num_inc_dir < MAX_INC_DIR) {
X        inc_dir[num_inc_dir++] = add_path_sep(optarg);
X        } else {
X        fprintf(stderr, "%s: too many include directories\n",
X            progname);
X        }
X    case 'D':
X    case 'U':
X        sprintf(tmp, " -%c%s", c, optarg);
X        strcat(cpp_cmd, tmp);
X        break;
X    case 'd':
X        define_macro = FALSE;
X        break;
X    case 'e':
X        extern_out = TRUE;
X        break;
X    case 'F':
X        s = escape_string(optarg);
X
X        decl_spec_prefix = s;
X        while (*s != '\0' && isascii(*s) && !isalnum(*s)) ++s;
X        if (*s == '\0') usage();
X        *s++ = '\0';
X        while (*s != '\0' && isascii(*s) && isalnum(*s)) ++s;
X        if (*s == '\0') usage();
X
X        declarator_prefix = s;
X        while (*s != '\0' && isascii(*s) && !isalnum(*s)) ++s;
X        if (*s == '\0') usage();
X        *s++ = '\0';
X        while (*s != '\0' && isascii(*s) && isalnum(*s)) ++s;
X        if (*s == '\0') usage();
X
X        declarator_suffix = s;
X        while (*s != '\0' && *s != '(') ++s;
X        if (*s == '\0') usage();
X        *s++ = '\0';
X
X        first_param_prefix = s;
X        while (*s != '\0' && isascii(*s) && !isalnum(*s)) ++s;
X        if (*s == '\0') usage();
X        *s++ = '\0';
X        while (*s != '\0' && *s != ',') ++s;
X        if (*s == '\0') usage();
X
X        middle_param_prefix = ++s;
X        while (*s != '\0' && isascii(*s) && !isalnum(*s)) ++s;
X        if (*s == '\0') usage();
X        *s++ = '\0';
X        while (*s != '\0' && isascii(*s) && isalnum(*s)) ++s;
X        if (*s == '\0') usage();
X
X        last_param_suffix = s;
X        while (*s != '\0' && *s != ')') ++s;
X        *s = '\0';
X
X        break;
X    case 'f':
X        proto_style = atoi(optarg);
X        if (proto_style < 0 || proto_style > PROTO_MACRO)
X        proto_style = PROTO_ANSI;
X        break;
X    case 'm':
X        macro_name = optarg;
X        break;
X    case 'p':
X        promote_param = FALSE;
X        break;
X    case 's':
X        static_out = TRUE;
X        break;
X    case 'V':
X        fprintf(stderr, "%s patchlevel %d\n", rcsid, PATCHLEVEL);
X        break;
X    case 'v':
X        variables_out = TRUE;
X        break;
X    case '?':
X    default:
X        usage();
X    }
X    }
X
X    if (proto_style == PROTO_MACRO && define_macro) {
X    printf("#if defined(__STDC__) || defined(__cplusplus)\n");
X    printf("# define %s(s) s\n", macro_name);
X    printf("#else\n");
X    printf("# define %s(s) ()\n", macro_name);
X    printf("#endif\n\n");
X    }
X
X    if (optind == argc) {
X    printf("/* stdin */\n");
X    parse_file();
X    } else {
X    for (i = optind; i < argc; ++i) {
X#ifdef MSDOS
X        if (freopen(argv[i], "r", yyin) == NULL) {
X        fprintf(stderr, "%s: cannot open file %s\n", progname, argv[i]);
X        continue;
X        }
X#else
X        sprintf(cmd, "%s %s", cpp_cmd, argv[i]);
X        if ((yyin = popen(cmd, "r")) == NULL) {
X        fprintf(stderr, "%s: error running cpp\n", progname);
X        continue;
X        }
X#endif
X        strcpy(cur_file, argv[i]);
X        line_num = 1;
X        printf("/* %s */\n", cur_file);
X        parse_file();
X#ifdef MSDOS
X        fclose(yyin);
X#else
X        pclose(yyin);
X#endif
X    }
X    }
X
X    if (proto_style == PROTO_MACRO && define_macro) {
X    printf("\n#undef %s\n", macro_name);
X    }
X
X    return 0;
X}
END_OF_cproto.c
if test 7676 -ne `wc -c <cproto.c`; then
    echo shar: \"cproto.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f semantic.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"semantic.c\"
else
echo shar: Extracting \"semantic.c\" \(10639 characters\)
sed "s/^X//" >semantic.c <<'END_OF_semantic.c'
X/* $Id: semantic.c 2.1 91/03/25 11:40:31 cthuang Exp $
X *
X * C prototype generator
X * These routines implement the semantic actions executed by the yacc parser.
X */
X#include <stdio.h>
X#include "cproto.h"
X#include "semantic.h"
X
X/* Output a string to standard output. */
X#define put_string(s) fputs(s, stdout)
X
X/* Create a new string by joining two strings with a space between them.
X * Return a pointer to the resultant string or NULL if an error occurred.
X */
Xstatic char *
Xconcat_string (a, b)
Xchar *a, *b;
X{
X    char *result;
X
X    if ((result = malloc((unsigned)(strlen(a) + strlen(b) + 2))) != NULL) {
X    strcpy(result, a);
X    strcat(result, " ");
X    strcat(result, b);
X    }
X    return result;
X}
X
X/* Return TRUE if the given identifier is really a typedef name.
X * Search the symbol table for the identifier.
X */
Xboolean
Xis_typedef_name (name)
Xchar *name;
X{
X    return (boolean)(find_symbol(typedef_names, name) != NULL);
X}
X
X/* Initialize a new declaration specifier part.
X */
Xvoid
Xnew_decl_spec (decl_spec, text, flags)
XDeclSpec *decl_spec;
Xchar *text;
Xunsigned short flags;
X{
X    decl_spec->text = strdup(text);
X    decl_spec->flags = flags;
X}
X
X/* Append two declaration specifier parts together.
X */
Xvoid
Xjoin_decl_specs (result, a, b)
XDeclSpec *result, *a, *b;
X{
X    result->text = concat_string(a->text, b->text);
X    result->flags = a->flags | b->flags;
X    free(a->text);
X    free(b->text);
X}
X
X/* Free storage used by a declaration specifier part.
X */
Xvoid
Xfree_decl_spec (decl_spec)
XDeclSpec *decl_spec;
X{
X    free(decl_spec->text);
X}
X
X/* Initialize the parameter structure.
X */
Xvoid
Xnew_parameter (param, decl_spec, declarator)
XParameter *param;        /* pointer to structure to be initialized */
XDeclSpec *decl_spec;        /* declaration specifier structure */
XDeclarator *declarator;        /* declarator structure */
X{
X    if (decl_spec == NULL) {
X    new_decl_spec(&(param->decl_spec), "", DE_JUNK);
X    } else {
X    param->decl_spec = *decl_spec;
X    }
X
X    if (declarator == NULL) {
X    new_declarator(&(param->declarator), "", "");
X    } else {
X    param->declarator = *declarator;
X    }
X}
X
X/* Free the storage used by the parameter.
X */
Xvoid
Xfree_parameter (param)
XParameter *param;
X{
X    free_decl_spec(&(param->decl_spec));
X    free_declarator(&(param->declarator));
X}
X
X/* Initialize a list of function parameters.
X */
Xvoid
Xnew_param_list (param_list, param)
XParameterList *param_list;
XParameter *param;
X{
X    Parameter *p;
X
X    p = (Parameter *)malloc((unsigned)sizeof(Parameter));
X    *p = *param;
X
X    param_list->first = param_list->last = p;
X    p->next = NULL;
X}
X
X/* Add the function parameter declaration to the list.
X */
Xvoid
Xadd_param_list (to, from, param)
XParameterList *to, *from;
XParameter *param;
X{
X    Parameter *p;
X
X    p = (Parameter *)malloc((unsigned)sizeof(Parameter));
X    *p = *param;
X
X    to->first = from->first;
X    from->last->next = p;
X    to->last = p;
X    p->next = NULL;
X}
X
X/* Free storage used by the elements in the function parameter list.
X */
Xvoid
Xfree_param_list (param_list)
XParameterList *param_list;
X{
X    Parameter *p, *next;
X
X    p = param_list->first;
X    while (p != NULL) {
X    next = p->next;
X    free_parameter(p);
X    free(p);
X    p = next;
X    }
X}
X
X/* Initialize an empty list of function parameter names.
X */
Xvoid
Xnew_ident_list (param_list)
XParameterList *param_list;
X{
X    param_list->first = param_list->last = NULL;
X}
X
X/* Add an item to the list of function parameter declarations but set only
X * the parameter name field.
X */
Xvoid
Xadd_ident_list (to, from, name)
XParameterList *to, *from;
Xchar *name;
X{
X    Parameter *p;
X    Declarator declarator;
X
X    p = (Parameter *)malloc((unsigned)sizeof(Parameter));
X    new_declarator(&declarator, name, name);
X    new_parameter(p, NULL, &declarator);
X
X    to->first = from->first;
X    if (to->first == NULL) {
X    to->first = p;
X    } else {
X    from->last->next = p;
X    }
X    to->last = p;
X    p->next = NULL;
X}
X
X/* Initialize a declarator.
X */
Xvoid
Xnew_declarator (d, name, text)
XDeclarator *d;
Xchar *name, *text;
X{
X    d->name = strdup(name);
X    d->text = strdup(text);
X    d->func_def = FUNC_NONE;
X    d->params.first = d->params.last = NULL;
X}
X
X/* Free storage used by a declarator.
X */
Xvoid
Xfree_declarator (d)
XDeclarator *d;
X{
X    free(d->name);
X    free(d->text);
X    free_param_list(&(d->params));
X}
X
X/* Initialize a declarator list and add the given declarator to it.
X */
Xvoid
Xnew_decl_list (decl_list, declarator)
XDeclaratorList *decl_list;
XDeclarator *declarator;
X{
X    Declarator *d;
X
X    d = (Declarator *)malloc((unsigned)sizeof(Declarator));
X    *d = *declarator;
X
X    decl_list->first = decl_list->last = d;
X    d->next = NULL;
X}
X
X/* Add the declarator to the declarator list.
X */
Xvoid
Xadd_decl_list (to, from, declarator)
XDeclaratorList *to, *from;
XDeclarator *declarator;
X{
X    Declarator *d;
X
X    d = (Declarator *)malloc((unsigned)sizeof(Declarator));
X    *d = *declarator;
X
X    to->first = from->first;
X    from->last->next = d;
X    to->last = d;
X    to->last->next = NULL;
X}
X
X/* Free storage used by the declarators in the declarator list.
X */
Xvoid
Xfree_decl_list (decl_list)
XDeclaratorList *decl_list;
X{
X    Declarator *d, *next;
X
X    d = decl_list->first;
X    while (d != NULL) {
X    next = d->next;
X    free_declarator(d);
X    free((char *)d);
X    d = next;
X    }
X}
X
X/* Search the list of parameters for a matching parameter name.
X * Return a pointer to the matching parameter or NULL if not found.
X */
Xstatic Parameter *
Xsearch_parameter_list (params, name)
XParameterList *params;
Xchar *name;
X{
X    Parameter *p;
X
X    for (p = params->first; p != NULL; p = p->next) {
X    if (strcmp(p->declarator.name, name) == 0)
X        return p;
X    }
X    return (Parameter *)NULL;
X}
X
X/* This routine is called to generate function prototypes from traditional
X * style function definitions.  For each parameter name in the declarator
X * list, find the matching parameter name in the parameter list and set
X * that parameter's declaration specifier.
X * This is also where we promote formal parameters.  Parameters of type
X * "char", "unsigned char", "short", or "unsigned short" get promoted to
X * "int".  Parameters of type "float" are promoted to "double".
X */
Xvoid
Xset_param_types (params, decl_spec, declarators)
XParameterList *params;
XDeclSpec *decl_spec;
XDeclaratorList *declarators;
X{
X    Declarator *d;
X    Parameter *p;
X    char *decl_spec_text, *s;
X
X    for (d = declarators->first; d != NULL; d = d->next) {
X    /* Search the parameter list for a matching name. */
X    p = search_parameter_list(params, d->name);
X    if (p == NULL) {
X        output_error();
X        fprintf(stderr, "declared argument \"%s\" is missing\n", d->name);
X    } else {
X        p->declarator.text = strdup(d->text);
X        decl_spec_text = decl_spec->text;
X        if (promote_param && strcmp(d->text, d->name) == 0) {
X            s = rindex(decl_spec_text, ' ');
X        s = (s != NULL) ? s+1 : decl_spec_text;
X        if (strcmp(s, "char") == 0 || strcmp(s, "short") == 0)
X            decl_spec_text = "int";
X        else if (strcmp(s, "float") == 0)
X            decl_spec_text = "double";
X        }
X        p->decl_spec.text = strdup(decl_spec_text);
X    }
X    }
X}
X
X/* Output a declaration specifier for an external declaration.
X */
Xstatic void
Xoutput_decl_spec (decl_spec)
XDeclSpec *decl_spec;
X{
X    if (extern_out && (decl_spec->flags & DE_STATIC) == 0) {
X    if (strstr(decl_spec->text, "extern") == NULL) {
X        put_string("extern ");
X    }
X    }
X    put_string(decl_spec->text);
X}
X
Xstatic void output_parameters();
X
X/* Output a declarator.
X */
Xstatic void
Xoutput_declarator (d)
XDeclarator *d;
X{
X    char *s;
X
X    if (d->func_def == FUNC_NONE) {
X    put_string(d->text);
X    } else {
X    if ((s = strstr(d->text, "()")) != NULL) {
X        *s = '\0';
X        put_string(d->text);
X        put_string(declarator_suffix);
X        if (proto_style == PROTO_MACRO)
X        printf(" %s(", macro_name);
X        fputc(*s++ = '(', stdout);
X        output_parameters(&(d->params));
X        fputc(*s++, stdout);
X        if (proto_style == PROTO_MACRO)
X        putchar(')');
X        put_string(s);
X    }
X    }
X}
X
X/* Output a function parameter.
X */
Xstatic void
Xoutput_parameter (p)
XParameter *p;
X{
X    char *s;
X
X    put_string(p->decl_spec.text);
X    if (proto_style == PROTO_ABSTRACT && strlen(p->declarator.name) > 0) {
X    s = strstr(p->declarator.text, p->declarator.name);
X    *s = '\0';
X    printf(" %s/*%s*/%s", p->declarator.text, p->declarator.name,
X        s + strlen(p->declarator.name));
X    *s = *(p->declarator.name);
X    } else {
X    if (strlen(p->declarator.text) > 0) {
X        putchar(' ');
X        output_declarator(&(p->declarator));
X    }
X    }
X}
X
X/* Output the list of function parameters.
X */
Xstatic void
Xoutput_parameters (params)
XParameterList *params;
X{
X    Parameter *p;
X
X    if (proto_style == PROTO_TRADITIONAL)
X    put_string("/*");
X
X    p = params->first;
X    if (p == NULL ||
X        (strcmp(p->decl_spec.text, "void") == 0 &&
X     strlen(p->declarator.text) == 0)) {
X    put_string("void");
X    } else {
X    put_string(first_param_prefix);
X    output_parameter(p);
X    p = p->next;
X    while (p != NULL) {
X        putchar(',');
X        put_string(middle_param_prefix);
X        output_parameter(p);
X        p = p->next;
X    }
X    put_string(last_param_suffix);
X    }
X
X    if (proto_style == PROTO_TRADITIONAL)
X    put_string("*/");
X}
X
X/* Output variable declarations.
X */
Xvoid
Xoutput_declarations (decl_spec, decl_list)
XDeclSpec *decl_spec;        /* declaration specifier */
XDeclaratorList *decl_list;    /* list of declared variables */
X{
X    Declarator *d;
X
X    if (!variables_out || (decl_spec->flags & DE_JUNK))
X    return;
X    if (!static_out && (decl_spec->flags & DE_STATIC))
X    return;
X
X    for (d = decl_list->first; d != NULL; d = d->next) {
X    if (d->func_def == FUNC_NONE) {
X        put_string(decl_spec_prefix);
X        output_decl_spec(decl_spec);
X        putchar(' ');
X        output_declarator(d);
X        put_string(";\n");
X    }
X    }
X}
X
X/* Output a function prototype.
X */
Xvoid
Xoutput_prototype (decl_spec, declarator)
XDeclSpec *decl_spec;
XDeclarator *declarator;
X{
X    Parameter *p;
X
X    if (proto_style == PROTO_NONE)
X    return;
X    if (decl_spec->flags & DE_JUNK)
X    return;
X    if (!static_out && (decl_spec->flags & DE_STATIC))
X    return;
X
X    /* Check for parameter names with no declaration specifiers.  This
X     * happens when a parameter name appears in the identifier list of a
X     * function definition but does not appear in the parameter declaration
X     * part.  The default type in this cause is "int".
X     */
X    for (p = declarator->params.first; p != NULL; p = p->next) {
X    if (strlen(p->decl_spec.text) == 0) {
X        free(p->decl_spec.text);
X        p->decl_spec.text = strdup("int");
X    }
X    }
X
X    put_string(decl_spec_prefix);
X    output_decl_spec(decl_spec);
X    put_string(declarator_prefix);
X    output_declarator(declarator);
X    put_string(";\n");
X}
END_OF_semantic.c
if test 10639 -ne `wc -c <semantic.c`; then
    echo shar: \"semantic.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f string.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"string.c\"
else
echo shar: Extracting \"string.c\" \(795 characters\)
sed "s/^X//" >string.c <<'END_OF_string.c'
X/* $Id: string.c 2.1 91/02/28 11:16:33 cthuang Exp $
X *
X * Some string handling routines
X */
X#include <stdio.h>
X#include "config.h"
X
X/* Copy the string into an allocated memory block.
X * Return a pointer to the copy.
X */
Xchar *
Xstrdup (s)
Xchar *s;
X{
X    char *dest;
X
X    if ((dest = malloc((unsigned)(strlen(s)+1))) == NULL) {
X    fprintf(stderr, "No memory to duplicate string.\n");
X    exit(1);
X    }
X    strcpy(dest, s);
X    return dest;
X}
X
X/* Return a pointer to the first occurence of the substring
X * within the string, or NULL if not found.
X */
Xchar *
Xstrstr (src, key)
Xchar *src, *key;
X{
X    char *s;
X    int keylen;
X
X    keylen = strlen(key);
X    s = index(src, *key);
X    while (s != NULL) {
X    if (strncmp(s, key, keylen) == 0)
X        return s;
X    s = index(s+1, *key);
X    }
X    return NULL;
X}
END_OF_string.c
if test 795 -ne `wc -c <string.c`; then
    echo shar: \"string.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f symbol.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"symbol.c\"
else
echo shar: Extracting \"symbol.c\" \(1900 characters\)
sed "s/^X//" >symbol.c <<'END_OF_symbol.c'
X/* $Id: symbol.c 2.1 91/02/28 11:16:35 cthuang Exp $
X *
X * Symbol table maintenance. Implements an abstract data type called
X * the symbol table.
X */
X#include <stdio.h>
X#include "config.h"
X#include "symbol.h"
X
X/* Create a symbol table.
X * Return a pointer to the symbol table or NULL if an error occurs.
X */
XSymbolTable *
Xcreate_symbol_table ()
X{
X    SymbolTable *symtab;
X    int i;
X
X    if ((symtab = (SymbolTable *)malloc(sizeof(SymbolTable))) != NULL) {
X    for (i = 0; i < SYM_MAX_HASH; ++i)
X        symtab->bucket[i] = NULL;
X    }
X    return symtab;
X}
X
X
X/* This is a simple hash function mapping a symbol name to a hash bucket. */
X
Xstatic int
Xhash (name)
Xchar *name;
X{
X    return (name[0] + name[1] + strlen(name)) % SYM_MAX_HASH;
X}
X
X
X/* Search the list of symbols <list> for the symbol <name>.
X * Return a pointer to the symbol or NULL if not found.
X */
Xstatic Symbol *
Xsearch_symbol_list (list, name)
XSymbol *list;
Xchar *name;
X{
X    Symbol *sym;
X
X    for (sym = list; sym != NULL; sym = sym->next) {
X    if (strcmp(sym->name, name) == 0)
X        return sym;
X    }
X    return NULL;
X}
X
X
X/* Look for symbol <name> in symbol table <symtab>.
X * Return a pointer to the symbol or NULL if not found.
X */
XSymbol *
Xfind_symbol (symtab, name)
XSymbolTable *symtab;
Xchar *name;
X{
X    return search_symbol_list(symtab->bucket[hash(name)], name);
X}
X
X
X/* If the symbol <name> does not already exist in symbol table <symtab>,
X * then add the symbol to the symbol table.
X * Return a pointer to the symbol or NULL on an error.
X */
XSymbol *
Xnew_symbol (symtab, name)
XSymbolTable *symtab;    /* symbol table */
Xchar *name;        /* symbol name */
X{
X    Symbol *sym;
X    int i;
X
X    if ((sym = find_symbol(symtab, name)) == NULL) {
X    if ((sym = (Symbol *)malloc(sizeof(Symbol))) != NULL) {
X        sym->name = strdup(name);
X        i = hash(name);
X        sym->next = symtab->bucket[i];
X        symtab->bucket[i] = sym;
X    }
X    }
X    return sym;
X}
END_OF_symbol.c
if test 1900 -ne `wc -c <symbol.c`; then
    echo shar: \"symbol.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
echo shar: End of shell archive.
exit 0
--
Chin Huang  [e-mail]  [e-mail]

exit 0 # Just in case...
--
Kent Landfield                   INTERNET: [e-mail]
Sterling Software, IMD           UUCP:     uunet!sparky!kent
Phone:    [phone]         FAX:      [phone]
Please send comp.sources.misc-related mail to [e-mail].